#!/bin/bash

# 确保脚本在出错时退出
set -e

# 显示彩色输出
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 清除可能存在的远程DOCKER_HOST配置，使用本地Docker socket
unset DOCKER_HOST

# 检查Docker连接函数
check_docker_connection() {
    echo -e "${BLUE}检查Docker连接...${NC}"
    if ! docker version >/dev/null 2>&1; then
        echo -e "${RED}错误：无法连接到Docker守护进程${NC}"
        echo -e "${YELLOW}请检查：${NC}"
        echo -e "1. Docker服务是否正在运行: systemctl status docker"
        echo -e "2. Docker socket权限: ls -la /var/run/docker.sock"
        echo -e "3. 当前用户是否在docker组中: groups \$USER"
        exit 1
    fi
    echo -e "${GREEN}Docker连接正常${NC}"
}

# 设置绝对路径
SYNOLOGY_PATH="/volume1/docker/hello-beer-pos"

# 部署状态文件路径
DEPLOY_STATE_FILE="$SYNOLOGY_PATH/.deploy_state"

# 命令行参数
FORCE_FRONTEND=false
FORCE_BACKEND=false
FORCE_DB=false
FORCE_ALL=false
SKIP_PULL=false

# 解析命令行参数
while [[ "$#" -gt 0 ]]; do
  case $1 in
    --force-frontend) FORCE_FRONTEND=true ;;
    --force-backend) FORCE_BACKEND=true ;;
    --force-db) FORCE_DB=true ;;
    --force-all) FORCE_ALL=true ;;
    --skip-pull) SKIP_PULL=true ;;
    --help)
      echo -e "${GREEN}Hello Beer POS 智能部署脚本${NC}"
      echo -e "用法: $0 [选项]"
      echo -e ""
      echo -e "${YELLOW}交互模式:${NC}"
      echo -e "  直接运行脚本将显示交互式菜单，支持10秒倒计时自动选择"
      echo -e ""
      echo -e "${YELLOW}命令行选项:${NC}"
      echo -e "  --force-frontend  强制重建前端容器"
      echo -e "  --force-backend   强制重建后端容器"
      echo -e "  --force-db        强制重建数据库容器"
      echo -e "  --force-all       强制重建所有容器"
      echo -e "  --skip-pull       跳过Git拉取步骤"
      echo -e "  --help            显示此帮助信息"
      echo -e ""
      echo -e "${YELLOW}功能特性:${NC}"
      echo -e "  • 智能检测容器状态和代码变更"
      echo -e "  • 交互式菜单选择部署方式"
      echo -e "  • 容器状态监控和日志查看"
      echo -e "  • 自动倒计时，无需等待用户输入"
      exit 0
      ;;
    *) echo -e "${RED}未知参数: $1${NC}"; exit 1 ;;
  esac
  shift
done

echo -e "${GREEN}=========================================${NC}"
echo -e "${GREEN}   Hello Beer POS 系统群晖智能部署脚本   ${NC}"
echo -e "${GREEN}=========================================${NC}"

# 检查Docker是否已安装
if ! command -v docker &> /dev/null; then
    echo -e "${RED}错误: Docker未安装。请在群晖控制面板中安装Docker。${NC}"
    exit 1
fi

# 检查Node.js和npm是否已安装
if ! command -v node &> /dev/null; then
    echo -e "${RED}警告: Node.js未安装，将使用Docker构建前端${NC}"
    USE_DOCKER_BUILD=true
else
    NODE_VERSION=$(node --version)
    echo -e "${GREEN}检测到Node.js版本: ${NODE_VERSION}${NC}"
    
    # 检查是否有多个Node.js版本并切换到v18
    if command -v /usr/local/bin/node18 &> /dev/null; then
        echo -e "${YELLOW}检测到多个Node.js版本，尝试切换到Node.js v18...${NC}"
        export PATH="/usr/local/bin/node18:$PATH"
        NODE_VERSION=$(node --version)
        echo -e "${GREEN}已切换到Node.js版本: ${NODE_VERSION}${NC}"
    elif command -v /volume1/@appstore/Node.js_v18/usr/local/bin/node &> /dev/null; then
        echo -e "${YELLOW}检测到群晖Node.js v18，尝试使用...${NC}"
        export PATH="/volume1/@appstore/Node.js_v18/usr/local/bin:$PATH"
        NODE_VERSION=$(node --version)
        echo -e "${GREEN}已切换到Node.js版本: ${NODE_VERSION}${NC}"
    fi
    
    USE_DOCKER_BUILD=false
fi

if ! command -v npm &> /dev/null; then
    echo -e "${RED}警告: npm未安装，将使用Docker构建前端${NC}"
    USE_DOCKER_BUILD=true
else
    NPM_VERSION=$(npm --version)
    echo -e "${GREEN}检测到npm版本: ${NPM_VERSION}${NC}"
fi

# 检查Docker连接
check_docker_connection

# 交互式菜单函数
show_menu() {
    echo -e "${BLUE}=========================================${NC}"
    echo -e "${BLUE}           部署选项菜单                  ${NC}"
    echo -e "${BLUE}=========================================${NC}"
    echo -e "${YELLOW}请选择要执行的操作：${NC}"
    echo -e "  ${GREEN}1${NC}) 智能检测部署 (默认)"
    echo -e "  ${GREEN}2${NC}) 强制重建所有容器"
    echo -e "  ${GREEN}3${NC}) 强制重建前端容器"
    echo -e "  ${GREEN}4${NC}) 强制重建后端容器"
    echo -e "  ${GREEN}5${NC}) 强制重建数据库容器"
    echo -e "  ${GREEN}6${NC}) 只拉取代码，不部署"
    echo -e "  ${GREEN}7${NC}) 查看容器状态"
    echo -e "  ${GREEN}8${NC}) 查看日志"
    echo -e "  ${GREEN}0${NC}) 退出"
    echo -e "${BLUE}=========================================${NC}"
}

# 用户选择函数（简化版，兼容性更好）
get_user_choice() {
    local choice=""

    # 如果已经有命令行参数，跳过菜单
    if [ $# -gt 0 ]; then
        return
    fi

    show_menu

    echo -e "${YELLOW}请输入选择 (1-8, 0退出)，直接按回车将使用智能检测部署:${NC}"
    echo -n "您的选择: "
    read -t 10 choice 2>/dev/null

    # 检查read命令是否成功（支持超时）
    if [ $? -ne 0 ] || [ -z "$choice" ]; then
        echo -e "\n${GREEN}使用默认选择：智能检测部署${NC}"
        choice="1"
    else
        echo -e "${GREEN}用户选择: ${choice}${NC}"
    fi

    case $choice in
        1)
            echo -e "${GREEN}选择: 智能检测部署${NC}"
            ;;
        2)
            echo -e "${GREEN}选择: 强制重建所有容器${NC}"
            FORCE_ALL=true
            ;;
        3)
            echo -e "${GREEN}选择: 强制重建前端容器${NC}"
            FORCE_FRONTEND=true
            ;;
        4)
            echo -e "${GREEN}选择: 强制重建后端容器${NC}"
            FORCE_BACKEND=true
            ;;
        5)
            echo -e "${GREEN}选择: 强制重建数据库容器${NC}"
            FORCE_DB=true
            ;;
        6)
            echo -e "${GREEN}选择: 只拉取代码${NC}"
            SKIP_DEPLOY=true
            ;;
        7)
            echo -e "${GREEN}选择: 查看容器状态${NC}"
            show_container_status
            exit 0
            ;;
        8)
            echo -e "${GREEN}选择: 查看日志${NC}"
            show_logs_menu
            exit 0
            ;;
        0)
            echo -e "${GREEN}退出部署脚本${NC}"
            exit 0
            ;;
        *)
            echo -e "${YELLOW}无效选择，使用默认的智能检测部署${NC}"
            ;;
    esac

    echo -e "${BLUE}=========================================${NC}"
}

# 显示容器状态函数
show_container_status() {
    echo -e "${BLUE}=========================================${NC}"
    echo -e "${BLUE}           容器状态信息                  ${NC}"
    echo -e "${BLUE}=========================================${NC}"

    echo -e "${YELLOW}正在运行的容器:${NC}"
    docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}" | grep -E "(hello-beer|NAMES)"

    echo -e "\n${YELLOW}所有相关容器(包括停止的):${NC}"
    docker ps -a --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" | grep -E "(hello-beer|NAMES)"

    echo -e "\n${YELLOW}Docker网络:${NC}"
    docker network ls | grep -E "(hello-beer|NETWORK)"

    echo -e "\n${YELLOW}磁盘使用情况:${NC}"
    docker system df
}

# 显示日志菜单函数
show_logs_menu() {
    echo -e "${BLUE}=========================================${NC}"
    echo -e "${BLUE}           日志查看菜单                  ${NC}"
    echo -e "${BLUE}=========================================${NC}"
    echo -e "${YELLOW}请选择要查看的日志：${NC}"
    echo -e "  ${GREEN}1${NC}) 后端服务日志"
    echo -e "  ${GREEN}2${NC}) 数据库日志"
    echo -e "  ${GREEN}3${NC}) 前端Nginx日志"
    echo -e "  ${GREEN}4${NC}) 所有容器日志概览"
    echo -e "  ${GREEN}0${NC}) 返回"

    read -p "请选择 (1-4, 0返回): " log_choice

    case $log_choice in
        1)
            echo -e "${GREEN}显示后端服务日志 (按Ctrl+C退出):${NC}"
            docker logs -f hello-beer-backend 2>/dev/null || echo -e "${RED}后端容器未运行${NC}"
            ;;
        2)
            echo -e "${GREEN}显示数据库日志 (按Ctrl+C退出):${NC}"
            docker logs -f hello-beer-db 2>/dev/null || echo -e "${RED}数据库容器未运行${NC}"
            ;;
        3)
            echo -e "${GREEN}显示前端Nginx日志 (按Ctrl+C退出):${NC}"
            docker logs -f hello-beer-frontend 2>/dev/null || echo -e "${RED}前端容器未运行${NC}"
            ;;
        4)
            echo -e "${GREEN}所有容器日志概览:${NC}"
            for container in hello-beer-backend hello-beer-db hello-beer-frontend; do
                if docker ps --format "{{.Names}}" | grep -q "^${container}$"; then
                    echo -e "\n${YELLOW}=== ${container} 最近日志 ===${NC}"
                    docker logs --tail 10 $container
                else
                    echo -e "\n${RED}=== ${container} 未运行 ===${NC}"
                fi
            done
            ;;
        0|*)
            return
            ;;
    esac
}

# 显示菜单并获取用户选择
get_user_choice "$@"

# 初始化状态变量
FRONTEND_CHANGED=false
BACKEND_CHANGED=false
DB_CHANGED=false
SKIP_DEPLOY=false

# 检测容器状态
check_container_status() {
    echo -e "${BLUE}检查容器运行状态...${NC}"

    # 检查前端容器状态
    if docker ps --format "table {{.Names}}\t{{.Status}}" | grep -q "^hello-beer-frontend"; then
        local frontend_status=$(docker ps --format "table {{.Names}}\t{{.Status}}" | grep "^hello-beer-frontend" | awk '{print $2}')
        echo -e "${GREEN}前端容器正在运行 (${frontend_status})${NC}"
    else
        echo -e "${YELLOW}前端容器未运行，需要重建${NC}"
        FRONTEND_CHANGED=true
    fi

    # 检查后端容器状态
    if docker ps --format "table {{.Names}}\t{{.Status}}" | grep -q "^hello-beer-backend"; then
        local backend_status=$(docker ps --format "table {{.Names}}\t{{.Status}}" | grep "^hello-beer-backend" | awk '{print $2}')
        echo -e "${GREEN}后端容器正在运行 (${backend_status})${NC}"
    else
        echo -e "${YELLOW}后端容器未运行，需要重建${NC}"
        BACKEND_CHANGED=true
    fi

    # 检查数据库容器状态
    if docker ps --format "table {{.Names}}\t{{.Status}}" | grep -q "^hello-beer-db"; then
        local db_status=$(docker ps --format "table {{.Names}}\t{{.Status}}" | grep "^hello-beer-db" | awk '{print $2}')
        echo -e "${GREEN}数据库容器正在运行 (${db_status})${NC}"
    else
        echo -e "${YELLOW}数据库容器未运行，需要重建${NC}"
        DB_CHANGED=true
    fi
}

# 检测代码变更
detect_changes() {
    echo -e "${BLUE}检测代码变更...${NC}"
    
    # 创建状态文件（如果不存在）
    if [ ! -f "$DEPLOY_STATE_FILE" ]; then
        echo -e "${YELLOW}未找到部署状态文件，将创建新文件${NC}"
        echo "last_deploy_time=$(date +%s)" > $DEPLOY_STATE_FILE
        echo "last_commit=\"\"" >> $DEPLOY_STATE_FILE
        FRONTEND_CHANGED=true
        BACKEND_CHANGED=true
        DB_CHANGED=true
        return
    fi
    
    # 加载上次部署状态
    source $DEPLOY_STATE_FILE
    
    # 如果所有容器都已标记为需要变更，跳过代码变更检测
    if [ "$FRONTEND_CHANGED" = true ] && [ "$BACKEND_CHANGED" = true ] && [ "$DB_CHANGED" = true ]; then
        return
    fi
    
    # 获取当前提交哈希
    CURRENT_COMMIT=$(cd $SYNOLOGY_PATH && git rev-parse HEAD)
    
    # 如果当前提交与上次部署相同且没有强制重建，则不需要任何操作
    if [ "$CURRENT_COMMIT" = "$last_commit" ] && [ "$FORCE_FRONTEND" = false ] && [ "$FORCE_BACKEND" = false ] && [ "$FORCE_DB" = false ]; then
        echo -e "${GREEN}代码未变更，不需要重新部署${NC}"
        exit 0
    fi
    
    # 检测哪些部分有变更
    if [ -n "$last_commit" ]; then
        # 检测前端变更
        if ! $FRONTEND_CHANGED && git diff --quiet $last_commit $CURRENT_COMMIT -- frontend/; then
            echo -e "${GREEN}前端代码未变更${NC}"
        else
            echo -e "${YELLOW}检测到前端代码变更${NC}"
            FRONTEND_CHANGED=true
        fi
        
        # 检测后端变更
        if ! $BACKEND_CHANGED && git diff --quiet $last_commit $CURRENT_COMMIT -- backend/; then
            echo -e "${GREEN}后端代码未变更${NC}"
        else
            echo -e "${YELLOW}检测到后端代码变更${NC}"
            BACKEND_CHANGED=true
        fi
        
        # 检测数据库迁移变更
        if ! $DB_CHANGED && git diff --quiet $last_commit $CURRENT_COMMIT -- backend/prisma/; then
            echo -e "${GREEN}数据库相关代码未变更${NC}"
        else
            echo -e "${YELLOW}检测到数据库相关代码变更${NC}"
            DB_CHANGED=true
        fi
    else
        # 首次部署，设置所有变更为true
        FRONTEND_CHANGED=true
        BACKEND_CHANGED=true
        DB_CHANGED=true
    fi
}

# 拉取最新代码
if [ "$SKIP_PULL" = false ]; then
    echo -e "${GREEN}拉取最新代码...${NC}"
    cd $SYNOLOGY_PATH
    git pull
fi

# 如果只是拉取代码，不进行部署
if [ "$SKIP_DEPLOY" = true ]; then
    echo -e "${GREEN}=========================================${NC}"
    echo -e "${GREEN}   代码拉取完成，跳过部署步骤   ${NC}"
    echo -e "${GREEN}=========================================${NC}"
    echo -e "${YELLOW}当前代码版本: $(git rev-parse --short HEAD)${NC}"
    echo -e "${YELLOW}最新提交: $(git log -1 --pretty=format:'%s')${NC}"
    exit 0
fi

# 处理强制重建标志
if [ "$FORCE_ALL" = true ]; then
    echo -e "${YELLOW}强制重建所有容器${NC}"
    FRONTEND_CHANGED=true
    BACKEND_CHANGED=true
    DB_CHANGED=true
elif [ "$FORCE_FRONTEND" = true ] || [ "$FORCE_BACKEND" = true ] || [ "$FORCE_DB" = true ]; then
    if [ "$FORCE_FRONTEND" = true ]; then
        echo -e "${YELLOW}强制重建前端容器${NC}"
        FRONTEND_CHANGED=true
    fi
    if [ "$FORCE_BACKEND" = true ]; then
        echo -e "${YELLOW}强制重建后端容器${NC}"
        BACKEND_CHANGED=true
    fi
    if [ "$FORCE_DB" = true ]; then
        echo -e "${YELLOW}强制重建数据库容器${NC}"
        DB_CHANGED=true
    fi
fi

# 检查容器状态（如果没有强制重建标志）
if [ "$FORCE_ALL" != true ]; then
    check_container_status
fi

# 检测代码变更
detect_changes

# 创建必要的目录
echo -e "${GREEN}创建必要的目录...${NC}"
mkdir -p $SYNOLOGY_PATH/logs/nginx $SYNOLOGY_PATH/uploads $SYNOLOGY_PATH/backups $SYNOLOGY_PATH/mysql-data

# 设置目录权限
echo -e "${GREEN}设置目录权限...${NC}"
chmod -R 755 $SYNOLOGY_PATH/logs $SYNOLOGY_PATH/uploads $SYNOLOGY_PATH/backups
chmod -R 777 $SYNOLOGY_PATH/mysql-data

# 检查.env文件是否存在，如果不存在则创建
if [ ! -f "$SYNOLOGY_PATH/.env" ]; then
    echo -e "${YELLOW}未找到.env文件，创建默认配置...${NC}"
    cat > $SYNOLOGY_PATH/.env << EOF
# 数据库配置
DB_PASSWORD=Hello_Beer_2023
DB_NAME=hello_beer

# JWT配置
JWT_SECRET=j8K2p0r5Zt7xW3vA9yB6nM4cD1eF0hG

# 应用配置
NODE_ENV=production
DATABASE_URL=mysql://root:Hello_Beer_2023@hello-beer-db:3306/hello_beer
APP_VERSION=1.0.0
EOF
    echo -e "${GREEN}.env文件已创建，请根据需要修改配置${NC}"
else
    echo -e "${GREEN}已找到.env文件，将使用现有配置${NC}"
    
    # 移除可能存在的DOCKER_HOST配置（不需要在.env中设置）
    if grep -q "DOCKER_HOST" "$SYNOLOGY_PATH/.env"; then
        echo -e "${YELLOW}清理.env文件中的DOCKER_HOST配置...${NC}"
        sed -i '/DOCKER_HOST/d' "$SYNOLOGY_PATH/.env"
        sed -i '/# Docker连接配置/d' "$SYNOLOGY_PATH/.env"
    fi
fi

# 加载.env文件中的环境变量
if [ -f "$SYNOLOGY_PATH/.env" ]; then
    export $(grep -v '^#' $SYNOLOGY_PATH/.env | xargs)
    echo -e "${GREEN}已加载环境变量配置${NC}"
fi

# 创建网络
echo -e "${GREEN}创建Docker网络...${NC}"
docker network create hello-beer-network 2>/dev/null || true

# 根据变更选择性重启服务
# 数据库服务
if [ "$DB_CHANGED" = true ]; then
    echo -e "${YELLOW}重启数据库服务...${NC}"
    docker stop hello-beer-db 2>/dev/null || true
    docker rm hello-beer-db 2>/dev/null || true
    
    docker run -d --name hello-beer-db \
      --restart always \
      --network hello-beer-network \
      -e MYSQL_ROOT_PASSWORD=${DB_PASSWORD} \
      -e MYSQL_DATABASE=${DB_NAME} \
      -e MYSQL_USER=hello_beer_user \
      -e MYSQL_PASSWORD=${DB_PASSWORD} \
      -v $SYNOLOGY_PATH/mysql-data:/var/lib/mysql \
      -p 3306:3306 \
      mysql:8.0 --default-authentication-plugin=mysql_native_password --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
    
    echo -e "${YELLOW}等待MySQL启动...${NC}"
    sleep 10
fi

# 后端服务
if [ "$BACKEND_CHANGED" = true ]; then
    echo -e "${YELLOW}重启后端服务...${NC}"
    docker stop hello-beer-backend 2>/dev/null || true
    docker rm hello-beer-backend 2>/dev/null || true
    
    # 清除可能存在的远程DOCKER_HOST配置，使用本地Docker socket
    unset DOCKER_HOST
    
    # 检查镜像是否存在，不存在才拉取
    if ! docker images binbin1213/hello-beer-backend:latest | grep -q latest; then
      echo -e "${BLUE}拉取后端镜像...${NC}"
      docker pull binbin1213/hello-beer-backend:latest
    else
      echo -e "${BLUE}使用现有后端镜像...${NC}"
    fi

    docker run -d --name hello-beer-backend \
      --restart always \
      --network hello-beer-network \
      -e NODE_ENV=${NODE_ENV} \
      -e DATABASE_URL=${DATABASE_URL} \
      -e PORT=3100 \
      -e JWT_SECRET=${JWT_SECRET} \
      -v $SYNOLOGY_PATH/backend:/app \
      -v $SYNOLOGY_PATH/logs:/app/logs \
      -v $SYNOLOGY_PATH/uploads:/app/uploads \
      -v $SYNOLOGY_PATH/backups:/app/backups \
      -p 3100:3100 \
      binbin1213/hello-beer-backend:latest
fi

# 前端服务
if [ "$FRONTEND_CHANGED" = true ]; then
    echo -e "${YELLOW}重建前端静态文件...${NC}"
    # 构建前端静态文件
    if [ -d "$SYNOLOGY_PATH/frontend" ]; then
      cd $SYNOLOGY_PATH/frontend
      if [ -f "package.json" ]; then
        # 如果检测到前端变更，直接构建（不需要额外的文件时间戳检查）
        echo -e "${YELLOW}检测到前端代码变更，开始构建...${NC}"
        # 记录构建开始时间
        BUILD_START_TIME=$(date +%s)

        if [ "$USE_DOCKER_BUILD" = true ]; then
          echo -e "${YELLOW}使用Docker构建前端...${NC}"
          # 创建一个持久化的node_modules卷来缓存依赖
          docker volume create hello-beer-node-modules 2>/dev/null || true

          # 使用Docker容器构建前端，挂载node_modules卷以缓存依赖
          docker run --rm \
            -v $SYNOLOGY_PATH/frontend:/app \
            -v hello-beer-node-modules:/app/node_modules \
            -w /app \
            node:18-alpine sh -c "
              echo '检查依赖缓存...'
              if [ ! -f 'node_modules/.package-lock.json' ] || [ 'package-lock.json' -nt 'node_modules/.package-lock.json' ]; then
                echo '安装/更新依赖...'
                echo '使用淘宝npm镜像源加速下载...'
                npm config set registry https://registry.npmmirror.com
                # 增加超时时间为5分钟
                npm config set fetch-timeout 300000
                npm ci --prefer-offline --no-audit
                cp package-lock.json node_modules/.package-lock.json
              else
                echo '使用缓存的依赖'
              fi
              echo '构建前端...'
              # 直接使用node_modules中的vite
              if [ -f 'node_modules/.bin/vite' ]; then
                echo '使用node_modules/.bin/vite构建...'
                ./node_modules/.bin/vite build
              elif [ -f 'node_modules/vite/bin/vite.js' ]; then
                echo '使用node执行vite.js构建...'
                node node_modules/vite/bin/vite.js build
              else
                echo '尝试设置NODE_PATH并使用vite...'
                export NODE_PATH="/app/node_modules"
                export PATH="/app/node_modules/.bin:$PATH"
                vite build || npm run build
              fi
            "
        else
          echo -e "${YELLOW}使用宿主机npm构建前端（更快）...${NC}"

          # 检查依赖是否需要安装
          if [ ! -d "node_modules" ] || [ "package-lock.json" -nt "node_modules/.package-lock.json" ]; then
            echo -e "${YELLOW}安装/更新前端依赖...${NC}"
            echo -e "${BLUE}使用淘宝npm镜像源加速下载...${NC}"
            # 临时设置npm镜像源为淘宝镜像
            npm config set registry https://registry.npmmirror.com
            # 增加超时时间为5分钟
            npm config set fetch-timeout 300000
            if [ -f "package-lock.json" ]; then
              npm ci --prefer-offline --no-audit
            else
              npm install --prefer-offline --no-audit
            fi
            # 检查是否需要全局安装vite
            if ! command -v vite &> /dev/null; then
              echo -e "${YELLOW}全局安装vite构建工具...${NC}"
              npm install -g vite
            fi
            # 创建时间戳文件
            touch node_modules/.package-lock.json
          else
            echo -e "${GREEN}依赖已是最新，跳过安装${NC}"
          fi

          echo -e "${YELLOW}构建前端静态文件...${NC}"
          
          # 查找可用的Node.js可执行文件
          NODE_PATHS=(
            "$(which node)"
            "/usr/local/bin/node18"
            "/usr/local/bin/node16"
            "/volume1/@appstore/Node.js_v18/usr/local/bin/node"
            "/volume1/@appstore/Node.js_v16/usr/local/bin/node"
          )
          
          NODE_PATH=""
          for path in "${NODE_PATHS[@]}"; do
            if [ -x "$path" ]; then
              NODE_PATH="$path"
              NODE_VERSION=$("$NODE_PATH" --version)
              echo -e "${GREEN}使用Node.js: $NODE_PATH (版本: $NODE_VERSION)${NC}"
              break
            fi
          done
          
          if [ -z "$NODE_PATH" ]; then
            echo -e "${RED}未找到可用的Node.js，将使用Docker构建${NC}"
            # 使用Docker容器构建
            docker run --rm \
              -v $SYNOLOGY_PATH/frontend:/app \
              -w /app \
              node:18-alpine sh -c "
                npm config set registry https://registry.npmmirror.com
                npm config set fetch-timeout 300000
                npm ci --prefer-offline --no-audit
                npm run build
              "
          else
            # 确保使用完整路径执行npm命令
            NPM_PATH=$(dirname "$NODE_PATH")/npm
            if [ ! -x "$NPM_PATH" ]; then
              NPM_PATH=$(which npm)
            fi
            
            echo -e "${YELLOW}使用npm路径: ${NPM_PATH}${NC}"
            
            # 设置PATH确保能找到正确的node和npm
            export PATH="$(dirname "$NODE_PATH"):$PATH"
            
            # 尝试使用npm运行构建
            if "$NPM_PATH" run build; then
              echo -e "${GREEN}前端构建成功${NC}"
            elif [ -f "node_modules/.bin/vite" ]; then
              echo -e "${YELLOW}使用node_modules/.bin/vite构建...${NC}"
              "$NODE_PATH" ./node_modules/.bin/vite build
            elif [ -f "node_modules/vite/bin/vite.js" ]; then
              echo -e "${YELLOW}使用node执行vite.js构建...${NC}"
              "$NODE_PATH" node_modules/vite/bin/vite.js build
            else
              echo -e "${RED}本地构建失败，尝试使用Docker容器构建...${NC}"
              # 使用Docker容器构建
              docker run --rm \
                -v $SYNOLOGY_PATH/frontend:/app \
                -w /app \
                node:18-alpine sh -c "
                  npm config set registry https://registry.npmmirror.com
                  npm config set fetch-timeout 300000
                  npm ci --prefer-offline --no-audit
                  npm run build
                "
            fi
          fi

        fi

        # 计算构建时间
        BUILD_END_TIME=$(date +%s)
        BUILD_DURATION=$((BUILD_END_TIME - BUILD_START_TIME))

        if [ $? -eq 0 ]; then
          echo -e "${GREEN}前端构建成功 (耗时: ${BUILD_DURATION}秒)${NC}"
        else
          echo -e "${RED}前端构建失败${NC}"
          exit 1
        fi

        cd $SYNOLOGY_PATH
      else
        echo -e "${RED}警告: 前端目录中没有找到package.json文件，跳过前端构建${NC}"
      fi
    else
      echo -e "${RED}警告: 未找到前端目录，跳过前端构建${NC}"
    fi
    
    echo -e "${YELLOW}重启前端服务...${NC}"
    docker stop hello-beer-frontend 2>/dev/null || true
    docker rm hello-beer-frontend 2>/dev/null || true
    
    docker run -d --name hello-beer-frontend \
      --restart always \
      --network hello-beer-network \
      -p 8081:80 \
      -v $SYNOLOGY_PATH/frontend/dist:/usr/share/nginx/html:ro \
      -v $SYNOLOGY_PATH/nginx/conf.d:/etc/nginx/conf.d:ro \
      -v $SYNOLOGY_PATH/logs/nginx:/var/log/nginx \
      nginx:alpine
fi

# 更新部署状态
CURRENT_COMMIT=$(cd $SYNOLOGY_PATH && git rev-parse HEAD)
echo "last_deploy_time=$(date +%s)" > $DEPLOY_STATE_FILE
echo "last_commit=\"$CURRENT_COMMIT\"" >> $DEPLOY_STATE_FILE
echo -e "${GREEN}已更新部署状态${NC}"

# 检查容器状态
echo -e "${GREEN}检查容器状态:${NC}"
docker ps -a | grep hello-beer

# 获取服务器IP地址，使用更可靠的方法
SERVER_IP=$(ip route get 1 | awk '{print $NF;exit}' 2>/dev/null || hostname -I | awk '{print $1}' 2>/dev/null || echo "服务器IP")

# 完成
echo -e "${GREEN}=========================================${NC}"
echo -e "${GREEN}   部署完成!   ${NC}"
echo -e "${GREEN}=========================================${NC}"
echo -e "${YELLOW}前端访问地址: http://${SERVER_IP}:8081${NC}"
echo -e "${YELLOW}后端API地址: http://${SERVER_IP}:3100${NC}"

echo -e "${GREEN}部署详情:${NC}"
echo -e "  前端容器: $([ "$FRONTEND_CHANGED" = true ] && echo "${YELLOW}已重建${NC}" || echo "${GREEN}无变更${NC}")"
echo -e "  后端容器: $([ "$BACKEND_CHANGED" = true ] && echo "${YELLOW}已重建${NC}" || echo "${GREEN}无变更${NC}")"
echo -e "  数据库容器: $([ "$DB_CHANGED" = true ] && echo "${YELLOW}已重建${NC}" || echo "${GREEN}无变更${NC}")"

# 提示查看日志
echo -e "${GREEN}查看后端日志:${NC}"
echo -e "${YELLOW}docker logs -f hello-beer-backend${NC}"

# 如果希望默认显示后端日志，取消下面的注释
# if [ "$BACKEND_CHANGED" = true ]; then
#   echo -e "${GREEN}显示后端日志（按Ctrl+C退出）:${NC}"
#   docker logs -f hello-beer-backend
# fi 
